﻿/*
 * 全局变量
 */
//#region

var G_TwoDimension = [];                            //二维数组数据源
var G_TwoDimension_Num = 0;                         //二维数组数据源个数（每个i的j累加）
var G_List = "";                                    //字符
var G_ZhuangWenLu = new Array(3), G_XianWenLu = new Array(3);       //记录庄问路、闲问路信息
var G_TwoWei_DYZ = [], G_TwoWei_XL = [], G_TwoWei_XQL = [];         //临时记录二维数组
var G_Genre = "";                              //类型（庄问路、闲问路）

function ReplaceLuDanFormat(ludan)
{
    ludan = ludan.replace(/a/g, ",100");
    ludan = ludan.replace(/b/g, ",110");
    ludan = ludan.replace(/c/g, ",101");
    ludan = ludan.replace(/d/g, ",111");
    ludan = ludan.replace(/e/g, ",200");
    ludan = ludan.replace(/f/g, ",210");
    ludan = ludan.replace(/g/g, ",201");
    ludan = ludan.replace(/h/g, ",211");
    ludan = ludan.replace(/i/g, ",300");
    ludan = ludan.replace(/j/g, ",310");
    ludan = ludan.replace(/k/g, ",301");
    ludan = ludan.replace(/l/g, ",311");
    return ludan.substr(1);
}

//#endregion
function ShowLudan(ldList,y,x,room)
{
    var room=room;
    if (ldList == null || ldList == "")
        return;
    //路单还原成100，200格式
    ldList = ReplaceLuDanFormat(ldList);
    //珠盘路1
    if(y==2){
        var html_zupanlu= room_ludanToImg_dl2(ldList,room);//龙湖珠盘路（ok）
    }else if(y==1){
        var html_zupanlu= room_ludanToImg_dl1(ldList,room);//百家乐珠盘路（OK）
    }
    StartAboutDaLu(ldList, room); //开始画大路
    StartDYZ(2 ,room);            //开始大眼仔算法   从第2列开始     参数等于0，则处理庄问路或闲问路
    StartXL(3,room);             //开始小路函数     从第3列开始     参数等于0，则处理庄问路或闲问路
    StartXQL(4,room);            //开始小强路函数   从第4列开始     参数等于0，则处理庄问路或闲问路

    if(x){
            //处理庄问路（取最后一位数）
            G_Genre = "ZhuangWenLu";
            DrawDALU(G_List + ",100", 0, room);
            DrawDALU_6(G_List + ",100", 0, room);
            StartDYZ(0,room);
            StartXL(0,room);
            StartXQL(0,room);
        
            //处理闲问路（取最后一位数）
            G_Genre = "XianWenLu";
            DrawDALU(G_List + ",200", 0, room);
            DrawDALU_6(G_List + ",200", 0, room);
            StartDYZ(0,room);
            StartXL(0,room);
            StartXQL(0,room);
        
            DealWenLuHtml(room) //绘制路问庄，庄问路
    }

}


/*去除当前字符串-及后面的字符*/
function GetDLNoHe(ludan) {
    if (ludan.indexOf("-") > -1)//存在"-"
    {
        return ludan.split("-")[0];
    }
    else {
        return ludan;
    }
}


//原始数据oriArr赋值给subArr
//连续并相同颜色的圆圈，同一组subArr赋值给twoWeiArr[oneWeiIndex]，然后subArr重新new
//如果不相同，则oneWeiIndex++
//最后构成twoWeiArr[oneWeiIndex]二维数组


///获取画大路用的二维数路信息
function twowei_arr(list) {
    var ludan;
    var strRet = "";
    var oriArr = new Array();               //原数据
    oriArr = list.split(",");
    var twoWeiArr = new Array();            //二维数组
    var subArr = new Array();               //临时一维数组，赋值给二维数组twoWeiArr[0]、twoWeiArr[1]...
    var needNewArr = false;
    var oneWeiIndex = 0;

    //   alert("ludanlist:" + list + "共计路单数:" + oriArr.length);
    for (var i = 0; i < oriArr.length; i++) {
        if (oriArr.length == 1) {//只有一个路单 ，不需要循环           
            subArr[subArr.length] = oriArr[i];
            twoWeiArr[oneWeiIndex] = subArr;
        }
        else //多于一个路单
        {
            if (i == 0)//第一个
            {
                subArr[i] = oriArr[i];
                twoWeiArr[oneWeiIndex] = subArr;
                // alert("oneWeiIndex:" + oneWeiIndex + "GetDLNoHe(oriArr[i]):" + GetDLNoHe(oriArr[i]));
            }
            else//第一个以外
            {
                //判断与上一个是否相同
                if (oriArr[i] != undefined && oriArr[i - 1] != undefined)//本路单与上一个路单都不为空
                {
                    if (GetDLNoHe(oriArr[i]).charAt(0) == GetDLNoHe(oriArr[i - 1]).charAt(0))//同一个子数组
                    {
                        subArr[subArr.length] = oriArr[i];
                        twoWeiArr[oneWeiIndex] = subArr;
                    }
                    else//需要重新生成一个新的子数组
                    {
                        oneWeiIndex++;//一级数组index加1
                        subArr = new Array();//新增一个子数组
                        subArr[subArr.length] = oriArr[i];
                        twoWeiArr[oneWeiIndex] = subArr;
                    }
                }
            }
        }
    }

    return twoWeiArr;

    //    //最终生成效果：
    ////  twoWeiArr[0][0]:100 - 1
    ////  twoWeiArr[1][0]:211 - 1
    ////  twoWeiArr[1][1]:200
    ////  twoWeiArr[1][2]:211
    ////  twoWeiArr[2][0]:110
    ////  twoWeiArr[2][1]:110 - 3
    ////  twoWeiArr[2][2]:110

    //// alert("一维长度：" + twoWeiArr.length);
}


//ZBTwoWeiArr 可能只是一部分哦(因为是生成大路过程中一步一步生成的)
//当前路子坐标写入前，检查当前路子按“上至下，左至右”的方式计算出来的坐标有没有被占用
function CheckZBUsed(leftPX, topPX, ZBTwoWeiArr)
{
    
    for (var i = 0; i < ZBTwoWeiArr.length; i++)
    {
        for (var j = 0; j < ZBTwoWeiArr[i].length; j++)
        {       

            if (ZBTwoWeiArr[i][j] == (leftPX + "-" + topPX))
            {
                return true;
            }
        }
    }
    return false;
}

//copy 多维数组
function DeepCopy(obj)
{
    var out = [], len = obj.length;
    for (var i = 0; i < len; i++)
    {
        if (obj[i] instanceof Array)
        {
            out[i] = DeepCopy(obj[i]);
        }
        else out[i] = obj[i];
    }
    return out;
}


//画大路
///这里list 只有100,200或者100-5这种,没有和局
function DrawDALU(list, beginRow,room) {
    var room=room;
    //debugger;
    var leftArray=[];
    var twoWeiArr = twowei_arr(list);
    if (beginRow > 0) {
        G_List = list;                              //赋值给全局变量G_List，为庄问路、闲问路打造数据
    }
    G_TwoDimension = twoWeiArr;                 //赋值给全局变量G_TwoDimension，为[大眼仔]、[小路]、[小强路]算法的数据源

    //最终生成效果：
    //  twoWeiArr[0][0]:100 - 1
    //  twoWeiArr[1][0]:211 - 1
    //  twoWeiArr[1][1]:200
    //  twoWeiArr[1][2]:211
    //  twoWeiArr[2][0]:110
    //  twoWeiArr[2][1]:110 - 3
    //  twoWeiArr[2][2]:110


    // alert("一维长度：" + twoWeiArr.length);

    //以下生成一个结构与twoWeiArr一模一样的空二维数组
    //用于保存当前twoWeiArr的路纸的坐标
    var ZBTwoWeiArr = DeepCopy(twoWeiArr);

    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ZBTwoWeiArr[i][j] = "";                                         //置空值，将记录坐标
            G_TwoDimension_Num++;                                           //全局变量二维数组数据源个数（每个i的j累加）
        }
    }
    var imgList = "<div class='show'></div>";
    var temp = 0.0;
    var tempImg = "";
    var colNum = 0;
    var leftPX = 0;
    var topPX = 0;
    var thisLD = "";

    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            thisLD = twoWeiArr[i][j];
            tempImg = room_ludanToImg_dl_nohe(thisLD);                      //取得图标名称

            var leftPX_topPX = GetLeft_topPX_DL(i, j, ZBTwoWeiArr);         //取得坐标位置
            leftPX = leftPX_topPX.split("-")[0];
            topPX = leftPX_topPX.split("-")[1];

            // 保存坐标
            ZBTwoWeiArr[i][j] = leftPX + "-" + topPX;

            if (thisLD.length > 0) {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;background:url(images/ludan/"+tempImg+");background-size:100% 100%;width:3.947%;height:15.6%;\"></span>";
            }
            else {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%\"> </span>";;
            }
        }
    }

    if (beginRow != undefined && beginRow > 0) {
        var divWdith=Math.max.apply(null, leftArray);
        self.postMessage({id:2,html:imgList,divWdith:divWdith,room:room});
    }    
}



// 画6号路单
function DrawDALU_6(list, beginRow,room) {
    var room=room;
    //debugger;
    var leftArray=[];
    var twoWeiArr = twowei_arr(list);
    if (beginRow > 0) {
        G_List = list;                              //赋值给全局变量G_List，为庄问路、闲问路打造数据
    }
    G_TwoDimension = twoWeiArr;                 //赋值给全局变量G_TwoDimension，为[大眼仔]、[小路]、[小强路]算法的数据源

    //最终生成效果：
    //  twoWeiArr[0][0]:100 - 1
    //  twoWeiArr[1][0]:211 - 1
    //  twoWeiArr[1][1]:200
    //  twoWeiArr[1][2]:211
    //  twoWeiArr[2][0]:110
    //  twoWeiArr[2][1]:110 - 3
    //  twoWeiArr[2][2]:110


    // alert("一维长度：" + twoWeiArr.length);

    //以下生成一个结构与twoWeiArr一模一样的空二维数组
    //用于保存当前twoWeiArr的路纸的坐标
    var ZBTwoWeiArr =[];


    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            G_TwoDimension_Num++;                                           //全局变量二维数组数据源个数（每个i的j累加）
        }
    }
    var imgList = "<div class='show'></div>";
    var tempImg = "";
    var leftPX = 0;
    var topPX = 0;
    var thisLD = "";
    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            thisLD = twoWeiArr[i][j];
            tempImg = room_ludanToImg_dl_nohe(thisLD);                      //取得图标名称
           if(ZBTwoWeiArr.length==0){
               var topPX=0;
               var leftPX=0;
           }
           else{
                // 高
                if(ZBTwoWeiArr.length%3==0){
                    var topPX=0;
                    var leftPX=Math.floor(ZBTwoWeiArr.length/3)*8.5;
                }
                else {
                    switch(ZBTwoWeiArr[ZBTwoWeiArr.length-1].topPX){
                        case 0:
                            var topPX=32.5;
                        break;
                        case 32.5:
                            var topPX=65;
                        break;
                    }
                    var leftPX=ZBTwoWeiArr[ZBTwoWeiArr.length-1].leftPX;
                }
           }

            ZBTwoWeiArr.push({topPX,leftPX});

            if (thisLD.length > 0) {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;background:url(images/ludan/"+tempImg+");background-size:100% 100%;width:8%;height:31%;\"></span>";
            }
            else {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%\"> </span>";;
            }
        }
    }

    if (beginRow != undefined && beginRow > 0) {
        var divWdith=Math.max.apply(null, leftArray);
        self.postMessage({id:6,html:imgList,divWdith:divWdith,room:room});
    }    
}

function GetLeft_topPX_DL(oneWeiIndex, serialIndex, ZBTwoWeiArr) {
    //leftPX_ori部分
    var leftPX = 0;

    var topPX = 0;
    var quyu = serialIndex % 6;

    var priorTopPX = 0;//上一个路子的Y坐标
    var priorLeftPX = 0;//上一个路子的X坐标


    //debugger;
    if (oneWeiIndex == 0)//第一个一维数组
    {
        if (serialIndex <= 5)//第一列
        {
            //leftPX = oneWeiIndex * 16;
            leftPX = 0;

            if (serialIndex == 0) {
                topPX = 0;
            }
            else {
                topPX = serialIndex * 16.6;
            }
        }
        else //第7个路子开始(第一个一维数组)
        {
            leftPX = ((serialIndex + 1) - 6) * 4.2;
            topPX = 83;
        }
        leftPX=parseInt(leftPX*10)/10;
        topPX=parseInt(topPX*10)/10;
    }
    else //第N个一维数组
    {
        //先按正常排列计算
        if (serialIndex == 0)//子数组中的第一个路子顶满最上面
        {
            topPX = 0;
            leftPX = oneWeiIndex * 4.2;
        }
        else//不是子数组中的第一个路子        
        {
            priorLeftPX = ZBTwoWeiArr[oneWeiIndex][serialIndex - 1].split("-")[0]*1;//上一个路纸的leftPX
            priorTopPX = ZBTwoWeiArr[oneWeiIndex][serialIndex - 1].split("-")[1]*1;//上一个路纸的topPX
            if (CheckZBUsed(priorLeftPX, parseInt((priorTopPX + 16.6)*10)/10, ZBTwoWeiArr))//xiangxia被占用
            {
                //向右走
                leftPX = priorLeftPX + 4.2;
                topPX = priorTopPX;
            }
            else //未被占用，正常走势安排坐标
            {
                if (priorTopPX != 83)
                {
                    // priorLeftPX= priorLeftPX + 16;
                    leftPX = priorLeftPX;

                    topPX = priorTopPX + 16.6;
                }
                else //向右走一列
                {
                    leftPX = priorLeftPX + 4.2;
                    topPX = priorTopPX;
                }
            }
            //以下算出按照正常走势应有的坐标
        }
        leftPX=parseInt(leftPX*10)/10;
        topPX=parseInt(topPX*10)/10;     
    }

    return leftPX + "-" + topPX;
}

//ludan可能包含"-"字符,即："100-3"/"200-3"指庄或者闲后连续开三局"和"
//只有庄和闲，或者"庄-5"/"闲-3"，不存在“和局,如300，311”等
//根据路单获取大路图片名称
function room_ludanToImg_dl_nohe(ludan) {
    var strRet = "";
    var he_ed1 = "";
    var he_ed2 = "";
    var thisImg = "";

    if (ludan.indexOf("-") > -1)//含和局的"局次"
    {
        he_ed1 = ludan.split("-")[0];
        he_ed2 = ludan.split("-")[1];

        if (he_ed1.startWith("1")) {
            strRet = "ludan_5_" + he_ed2 + ".png";
        }
        else if (he_ed1.startWith("2")) {
            strRet = "ludan_4_" + he_ed2 + ".png";
        }
    }
    else {
        if (ludan.startWith("1")) {
            strRet = "ludan_5.png";
        }
        else if (ludan.startWith("2")) {
            strRet = "ludan_4.png";
        }
    }
    return strRet;
}

String.prototype.startWith = function (str) {
    if (str == null || str == "" || this.length == 0 || str.length > this.length) {
        return false;
    }
    if (this.substr(0, str.length) == str) {
        return true;
    } else {
        return false;
    }
    return true;
};

//右边大路开始处理
function StartAboutDaLu(list,room) {
    var arr_dl = new Array();//大路
    var lst_dl = "";
    try {
        list.split(',').forEach(function (i, idx) {//去掉开始的和局
            if (i.startWith("3"))
                list = list.substr(4);
            else
                throw "break";//forEach无法break，采用try catch形式终止
        });
    } catch (e) {
        if (e !== "break") throw e;
    }
    list.split(',').forEach(function (i, idx) {//去掉和局
        var len = arr_dl.length;
        if (i.startWith("3")) {//和局直接在数组结尾+1
            arr_dl[len - 1][1]++;
        }
        else {
            arr_dl[len] = new Array(2);
            arr_dl[len][0] = i;
            arr_dl[len][1] = 0;
        }
    });
    arr_dl.forEach(function (i, idx) {
        lst_dl += "," + arr_dl[idx][0] + (arr_dl[idx][1] == 0 ? "" : "-" + arr_dl[idx][1]);
    });
    if (lst_dl != "") {
        DrawDALU(lst_dl.substr(1), 1,room);//画大路
        DrawDALU_6(lst_dl.substr(1), 1,room);//画大路(lst_dl.substr(1), 1);//画6好路单
    }
}

//oneWeiIndex为twoWeiArr的一维index
//serialNum为当前路音在子数组中的排序
//ZBTwoWeiArr 只是现有已有这部分二维码的坐标内容
function GetLeftPX_DL(oneWeiIndex, serialIndex, ZBTwoWeiArr) {
    var leftPX = 0;
    //debugger;
    if (oneWeiIndex == 0)//第一列
    {
        if (serialIndex < 6) {
            leftPX = oneWeiIndex * 16;
        }
        else {
            leftPX = ((serialIndex + 1) - 6) * 16;
        }
    }
    else //第N列 n>1
    {
        if (serialIndex < 6) {
            leftPX = oneWeiIndex * 16;
        }
        else //大于6
        {
            leftPX = ((serialIndex + 1) - 6) * 16 + oneWeiIndex * 16;
        }
    }
    return leftPX;
    
}

//ZBTwoWeiArr 只是现有已有这部分二维码的坐标内容
function GettopPX_DL(serialNum, ZBTwoWeiArr) {
    var topPX = 0;
    var quyu = serialNum % 6;

    if (serialNum <= 6)//6个数以内
    {
        if (quyu == 1) {
            topPX = 0;
        }
        else if (quyu == 2) {
            topPX = 16;
        }
        else if (quyu == 3) {
            topPX = 32;
        }
        else if (quyu == 4) {
            topPX = 48;
        }
        else if (quyu == 5) {
            topPX = 64;
        }
        else if (quyu == 0) {
            topPX = 80;
        }
    }
    else//第七个ludan开始
    {
        topPX = 80;
    }
    return topPX;
}
//以上为大路
//#endregion

/* 珠盘路算法 */
//#region
function room_ludanToImg_dl1(list,room) {
    var leftArray=[];
    var ludan;              //标识
    var strRet = "<div class='show'></div>";
    var thisImg = "";       //图片

    for (var i = 0; i < list.split(",").length; i++) {
        ludan = list.split(",")[i];
        thisImg = ""

        switch (ludan) {
            case "100"://100   庄
                thisImg = "ludan_1.png";
                break;
            case "110"://110
                thisImg = "ludan_1_2.png";
                break;
            case "101"://101
                thisImg = "ludan_1_3.png";
                break;
            case "111"://111
                thisImg = "ludan_1_4.png";
                break;
            case "200"://200
                thisImg = "ludan_2.png";
                break;
            case "210"://210
                thisImg = "ludan_2_2.png";
                break;
            case "201"://201
                thisImg = "ludan_2_3.png";
                break;
            case "211"://211
                thisImg = "ludan_2_4.png";
                break;
            case "300"://300
                thisImg = "ludan_3.png";
                break;
            case "310"://310
                thisImg = "ludan_3_2.png";
                break;
            case "301"://301
                thisImg = "ludan_3_3.png";
                break;
            case "311"://311
                thisImg = "ludan_3_4.png";
                break;
            default:
                thisImg = "";
                break
        }
        var temp = (i + 1) / 6;
        var colNum = parseFloat(Math.ceil(temp));
        //colNum 确定第几列
        var leftPX = (colNum - 1) *12.7;
        var topPX = GettopPX(i + 1);
        if (thisImg.length > 0)
        {
            leftArray.push(leftPX);
            strRet += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;background:url(images/ludan/"+thisImg+");background-size:100% 100%;height:15.1%;width:11.4%\" ></span>";
        }
        else {
            leftArray.push(leftPX);
            strRet += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%\"> </span>";
        }
    }
    var divWdith=Math.max.apply(null, leftArray);
    self.postMessage({id:1,html:strRet,divWdith:divWdith,room:room});
    return strRet;
}

function room_ludanToImg_dl2(list,room) {

    var leftArray=[];
    var ludan;              //标识
    var strRet = "<div class='show'></div>";
    var thisImg = "";       //图片

    for (var i = 0; i < list.split(",").length; i++) {
        ludan = list.split(",")[i];
        thisImg = ""

        switch (ludan) {
            case "100"://100   庄
                thisImg = "ludan_1_L.png";
                break;
            case "110"://110
                thisImg = "ludan_1_2.png";
                break;
            case "101"://101
                thisImg = "ludan_1_3.png";
                break;
            case "111"://111
                thisImg = "ludan_1_4.png";
                break;
            case "200"://200
                thisImg = "ludan_2_L.png";
                break;
            case "210"://210
                thisImg = "ludan_2_2.png";
                break;
            case "201"://201
                thisImg = "ludan_2_3.png";
                break;
            case "211"://211
                thisImg = "ludan_2_4.png";
                break;
            case "300"://300
                thisImg = "ludan_3.png";
                break;
            case "310"://310
                thisImg = "ludan_3_2.png";
                break;
            case "301"://301
                thisImg = "ludan_3_3.png";
                break;
            case "311"://311
                thisImg = "ludan_3_4.png";
                break;
            default:
                thisImg = "";
                break
        }
        var temp = (i + 1) / 6;
        var colNum = parseFloat(Math.ceil(temp));
        //colNum 确定第几列
        var leftPX = (colNum - 1) *12.7;
        var topPX = GettopPX(i + 1);
        if (thisImg.length > 0)
        {
            leftArray.push(leftPX);
            strRet += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;background:url(images/ludan/"+thisImg+");background-size:100% 100%;height:15.1%;width:11.4%\" ></span>";
        }
        else {
            leftArray.push(leftPX);
            strRet += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%\"> </span>";
        }
    }
    var divWdith=Math.max.apply(null, leftArray);
    self.postMessage({id:1,html:strRet,divWdith:divWdith,room:room});
    return strRet;
}

///获取离顶部距离px数
function GettopPX(serialNum) {
    var topPX = 0;

    var quyu = serialNum % 6;
    if (quyu == 1) {
        topPX = 0.5;
    }
    else if (quyu == 2) {
        topPX = 17;
    }
    else if (quyu == 3) {
        topPX = 33.8;
    }
    else if (quyu == 4) {
        topPX = 50.5;
    }
    else if (quyu == 5) {
        topPX = 67;
    }
    else if (quyu == 0) {
        topPX = 84;
    }
    return topPX;
}
//#endregion




/* 大眼仔函数 */
//#region
function StartDYZ(beginRow,room) {
    /* 定义局部变量 */
    //#region
    var room=room;
    var DYZ_TwoDimension_Total = new Array();                 //大眼仔一维数组总数据（通过每个一维的值都是存储一维，变成二维）
    var _arr = new Array();                                   //临时一维数组    
    
    if (!IsRegulationDYZ()) {
        return false;
    }    
    //#endregion

    var _fristRow = 0;          //第一列
    for (var i = 0; i < G_TwoDimension.length; i++) {
        var _flag = false;      //标记是否直落
        var _twoRow = 0;        //第二列        
        for (var j = 0; j < G_TwoDimension[i].length; j++) {
            if (i == 0) continue; _twoRow = _arr.length;
            //先判断有无、直落，第二列有2个子路开始
            if (i == 1 && G_TwoDimension.length >= 2 && G_TwoDimension[i].length >= 2 && j >= 1) {
                //#region
                //判断有无，添加结果到DYZ_TwoDimension_Total中
                //如果当前子路G_TwoDimension[i][j]与上一子路G_TwoDimension[i-1][j]都存在，则有。路子为红色。
                if (G_TwoDimension[i][j] != undefined && G_TwoDimension[i][j].length > 0 && G_TwoDimension[i - 1][j] != undefined && G_TwoDimension[i - 1][j].length > 0) {                    
                    _arr.push("100");        //属于递增添加值
                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需赋值
                        DYZ_TwoDimension_Total[_fristRow] = _arr;       //直接结束
                    }
                    //如果属于该列最后一个路子，并且还有下一列，该i列与i-1列不齐整
                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] != undefined && G_TwoDimension[i].length != G_TwoDimension[i - 1].length) {
                        //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                        DYZ_TwoDimension_Total[_fristRow] = _arr;
                        _arr = new Array();     //临时第二列的一维数组                        
                        _fristRow++;
                    }

                } else {

                    //如果是无，则跳一列。路子为蓝色
                    if ((G_TwoDimension[i - 1][j] == undefined || G_TwoDimension[i - 1][j].length == 0) && !_flag) {

                        //跳一列之前，先将_arr数组赋给DYZ_TwoDimension_Total[_fristRow]，并重新new _arr数组（除第二列第二行外）。如果初始化就是该路子，不应该new，所以要加判断，不等于第二列第二行
                        if (i >= 1 && j > 1) {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            _fristRow++;
                        }
                                                                        
                        _arr.push("200");
                                                
                        _flag = true;           //出现一次“无”后，如果接下来还有子路，则都是直落，并且继续跳一列。路子为红色
                        if (G_TwoDimension[i][j + 1] != undefined && G_TwoDimension[i][j + 1].length > 0) {         
                            
                            //有直落，将“无”存起来。再跳一列，new一个新数组，用于存“直落”
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            _fristRow++;        //如果出现无、直落，都需要跳一列
                        } else if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {               //出现“无”，并且为最后一个，需赋值
                            DYZ_TwoDimension_Total[_fristRow] = _arr;       //直接结束
                        }
                        continue;               //无、直落都跳过当次循环
                    }

                    //如果是直落，接下来都是直落。路子为红色
                    if (_flag) {                        
                        _arr.push("100");                       //判断直落，添加结果到_arr中
                    }

                    //如果是直落，并且属于最后一个数组需赋值
                    if (_flag && j == G_TwoDimension[i].length -1) {
                        //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                        DYZ_TwoDimension_Total[_fristRow] = _arr;
                        _arr = new Array();     //临时第二列的一维数组

                        ////如果是直落，则需要跳一列，方便第三列直接加入新数据“不齐整”
                        //if (_flag) {
                            _fristRow++;
                        //}
                    }
                    
                }
                //#endregion

                //第三列后，从齐整、不齐整先判断
            } else if(i > 1){
                //判断齐整、不齐整，添加结果到临时数组_arr中
                if (j == 0) {
                    if (G_TwoDimension[i - 1].length == G_TwoDimension[i - 2].length) {
                        //如果_arr[_arr.length-1]为2开头的话，需要new
                        if (_arr.length > 0 && _arr[_arr.length - 1] != undefined && _arr[_arr.length - 1].length > 0 && _arr[_arr.length - 1].substring(0,1) == "2") {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                        }
                        _arr.push("100");                   //齐整
                    } else {
                        //如果_arr长度大于0，并且_arr[_arr.length-1]=="100"的话，需要new
                        if (_arr.length > 0 && _arr[_arr.length - 1] == "100") {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                        }
                        _arr.push("200");                   //不齐整
                    }

                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需将结果保存起来
                        DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                    }
                } else {
                    //从第二行开始：判断有、无、直落，添加结果到DYZ_TwoDimension_Total中
                    //#region
                    //有：如果当前子路G_TwoDimension[i][j]与上一子路G_TwoDimension[i-1][j]都存在，则有。路子为红色。
                    if (G_TwoDimension[i][j] != undefined && G_TwoDimension[i][j].length > 0 && G_TwoDimension[i - 1][j] != undefined && G_TwoDimension[i - 1][j].length > 0) {

                        //如果上一值为“齐整”，则直接push，否则new一个数组并_fristRow++
                        if (_arr[_arr.length - 1] == "100") {
                            _arr.push("100");        //属于递增添加值
                        } else {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                            _arr.push("100");        //属于递增添加值
                        }
                        if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需将结果保存起来
                            DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                        }

                        //无：路子为蓝色，直落：路子为红色
                    } else {

                        //无：路子为蓝色，并且不是直落
                        if ((G_TwoDimension[i - 1][j] == undefined || G_TwoDimension[i - 1][j].length == 0) && !_flag) {
                            //如果上一值为“齐整”，则new一个数组并_fristRow++，否则直接push
                            if (_arr[_arr.length - 1] == "100") {
                                DYZ_TwoDimension_Total[_fristRow] = _arr;
                                _arr = new Array();     //临时第二列的一维数组
                                _fristRow++;
                                _arr.push("200");        //属于递增添加值
                            } else {
                                _arr.push("200");        //属于递增添加值
                            }

                            //为最后一个，需将结果保存起来
                            if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {
                                DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                            }

                            _flag = true;           //出现一次“无”后，如果接下来还有子路，则都是直落，并且继续跳一列。路子为红色
                            if (G_TwoDimension[i][j + 1] != undefined && G_TwoDimension[i][j + 1].length > 0) {

                                //有直落，将“无”存起来。再跳一列，new一个新数组，用于存“直落”
                                DYZ_TwoDimension_Total[_fristRow] = _arr;
                                _arr = new Array();     //临时第二列的一维数组
                                
                                _fristRow++;        //如果出现无、直落，都需要跳一列
                            }
                            continue;               //无、直落都跳过当次循环
                        }
                                                                        
                        //如果是直落，接下来都是直落。路子为红色
                        if (_flag) {
                            _arr.push("100");                       //判断直落，添加结果到_arr中
                        }

                        //如果是直落，并且属于最后一个数组需赋值
                        if (_flag && j == G_TwoDimension[i].length - 1) {
                            //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            //如果是直落，则需要跳一列，方便第三列直接加入新数据“不齐整”                            
                            _fristRow++;                            
                        }
                    }
                    //#endregion
                }                
            }
        }
    }
        
    //构造Html代码（图标名、坐标值）并渲染到页面
    CreateIocCoordinateDYZ(DYZ_TwoDimension_Total, beginRow,room);
        
}

/*
 * 是否符合大眼仔函数规则
 * 如果二维数组大于等于2，并且第二列第二行有数据，或者第三列有数据
 */
function IsRegulationDYZ() {
    if (G_TwoDimension.length >= 2 && G_TwoDimension[1].length >= 2 || G_TwoDimension.length >= 3) {
        return true;
    }
    return false;
}

/*
 * 构造Html代码并渲染到页面
 */
function CreateIocCoordinateDYZ(twoWeiArr, beginRow,room) {
    
    //以下生成一个结构与twoWeiArr一模一样的空二维数组
    //用于保存当前twoWeiArr的路子的坐标
    var ZBTwoWeiArr = DeepCopy(twoWeiArr);      //二维数组坐标值    
    
    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ZBTwoWeiArr[i][j] = "";                                         //置空值，将记录坐标                  
        }
    }
    var imgList = "<div class='show'></div>";                           //构造字符串
    var tempImg = "";                           //图片名
    var leftPX = 0;                             //图标左移像素
    var topPX = 0;                              //图标顶移像素
    var ludan = "";                            //当前路单
    var leftArray=[];
    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ludan = twoWeiArr[i][j];
            tempImg = getImgDYZ(ludan);                      //取得图标名称
            
            var leftPX_topPX = GetLeft_topPX_DYZ1(i, j, ZBTwoWeiArr,4.1,16.9);         //取得坐标位置

            leftPX = leftPX_topPX.split("-")[0];
            topPX = leftPX_topPX.split("-")[1];

            // 保存坐标
            ZBTwoWeiArr[i][j] = leftPX + "-" + topPX;

            if (ludan.length > 0) {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;width:2%;height:8%;border-radius:50%;"+tempImg+");\"></span>";                
            }
            else {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;width:3.4%;height:0;padding-bottom:3.4%;\"> </span>";;
            }            
        }
    }

    if (beginRow != undefined && beginRow > 0) {
        G_TwoWei_DYZ = twoWeiArr;
        var divWdith=Math.max.apply(null, leftArray);
        self.postMessage({id:3,html:imgList,divWdith:divWdith,room:room});
    } else {
        DealWenLu(G_TwoWei_DYZ, twoWeiArr, "DYZ",room);
    }

}
//根据当前路子,获取大眼仔路子图片名称
function getImgDYZ(ludan) {
    var temp = "";
    if (ludan != undefined && ludan.length > 0 && ludan.substring(0,1) == "1") {
        temp = "border:1.5px solid #f00010;border-radius:50%";
    } else {
        temp = "border:1.5px solid #0001f2;border-radius:50%";
    }
    return temp;
}

//根据当前路子,获取大眼仔路子坐标。   参数:一维数组索引 i、序号索引 j、已存储的坐标值
/* 算法：
 * 1、第一维数组，第一列，小于6的，topPX为j*8。从第7个起，leftPX = ((serialIndex + 1) - 6) * 8;topPX = 80;
 * 2、第N个一维数组，第一个topPX = 0;leftPX = i * 8;
 * 3、第N个一维数组，不是第一个的
 *    找出上一个路子的坐标。
 *    检查当前路子是否被占用，如果占用就往右走（topPX用上一个路子的，leftPX+8），检查2-6行，往右是（2-5行）。
 *    如果不占用，第2-6行在本列，第7个及以上往右走一列（leftPX以上一个路子为基础）
 */

function GetLeft_topPX_DYZ1(oneWeiIndex, serialIndex, ZBTwoWeiArr, offset,offtop) {    
    var leftPX = 0;
    var topPX = 0;
    var priorTopPX = 0;//上一个路子的Y坐标
    var priorLeftPX = 0;//上一个路子的X坐标
    
    if (oneWeiIndex == 0)//第一个一维数组
    {
        if (serialIndex <= 5)//第一列
        {            
            leftPX = 0;

            if (serialIndex == 0) {
                topPX = 0;
            }
            else {
                topPX = serialIndex * offtop;
            }
        }
        else //第7个路子开始(第一个一维数组)
        {
            leftPX = ((serialIndex + 1) - 6) * offset;
            topPX = (offtop * 5);
        }
    }
    else //第N个一维数组
    {
        //先按正常排列计算
        if (serialIndex == 0)//子数组中的第一个路子顶满最上面
        {
            topPX = 0;
            leftPX = oneWeiIndex * offset;
        }
        else//不是子数组中的第一个路子        
        {
            priorLeftPX = (ZBTwoWeiArr[oneWeiIndex][serialIndex - 1].split("-")[0])*1;    //上一个路纸的leftPX
            priorTopPX = (ZBTwoWeiArr[oneWeiIndex][serialIndex - 1].split("-")[1])*1;     //上一个路纸的topPX
            if (CheckZBUsed(priorLeftPX, priorTopPX + offset, ZBTwoWeiArr))                    //检查当前路子是否被占用
            {
                //向右走
                leftPX = priorLeftPX + offset;
                topPX = priorTopPX;
            }
            else //未被占用，正常走势安排坐标
            {
                if (priorTopPX !=(offtop*5)) {            
                    leftPX = priorLeftPX;

                    topPX = priorTopPX + offtop;
                }
                else //向右走一列
                {
                    
                    leftPX = priorLeftPX + offset;
                    topPX = priorTopPX;
                }
            }
            //以下算出按照正常走势应有的坐标
        }
    }    

    return leftPX + "-" + topPX;
}
//#endregion

/* 小路函数 */
//#region
function StartXL(beginRow,room) {

    var DYZ_TwoDimension_Total = new Array();                  //小路一维数组总数据（通过每个一维的值都是存储一维，变成二维）
    var _arr = new Array();                                   //临时一维数组  

    if (!IsRegulationXL()) {
        return false;
    } 
    var _fristRow = 0;          //第一列
    for (var i = 0; i < G_TwoDimension.length; i++) {
        var _flag = false;      //标记是否直落
        var _twoRow = 0;        //第二列        
        for (var j = 0; j < G_TwoDimension[i].length; j++) {
            if (i <= 1) continue; _twoRow = _arr.length;
            //先判断有无、直落，从第三列有2个子路开始
            if (i == 2 && G_TwoDimension.length >= 2 && G_TwoDimension[i].length >= 2 && j >= 1) {
                //#region
                //判断有无，添加结果到DYZ_TwoDimension_Total中
                //如果当前子路G_TwoDimension[i][j]与上一子路G_TwoDimension[i-2][j]都存在，则有。路子为红色。
                if (G_TwoDimension[i][j] != undefined && G_TwoDimension[i][j].length > 0 && G_TwoDimension[i - 2][j] != undefined && G_TwoDimension[i - 2][j].length > 0) {
                    _arr.push("100");        //属于递增添加值
                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需赋值
                        DYZ_TwoDimension_Total[_fristRow] = _arr;       //直接结束
                    }
                    //如果属于该列最后一个路子，并且还有下一列，该i列与i-2列不齐整
                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] != undefined && G_TwoDimension[i].length != G_TwoDimension[i - 2].length) {
                        //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                        DYZ_TwoDimension_Total[_fristRow] = _arr;
                        _arr = new Array();     //临时第二列的一维数组                        
                        _fristRow++;
                    }

                } else {

                    //如果是无，则跳一列。路子为蓝色
                    if ((G_TwoDimension[i - 2][j] == undefined || G_TwoDimension[i - 2][j].length == 0) && !_flag) {

                        //跳一列之前，先将_arr数组赋给DYZ_TwoDimension_Total[_fristRow]，并重新new _arr数组（除第三列第二行外）。如果初始化就是该路子，不应该new，所以要加判断，不等于第三列第二行
                        if (i >= 2 && j > 1) {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            _fristRow++;
                        }

                        _arr.push("200"); 

                        _flag = true;           //出现一次“无”后，如果接下来还有子路，则都是直落，并且继续跳一列。路子为红色
                        if (G_TwoDimension[i][j + 1] != undefined && G_TwoDimension[i][j + 1].length > 0) {

                            //有直落，将“无”存起来。再跳一列，new一个新数组，用于存“直落”
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            _fristRow++;        //如果出现无、直落，都需要跳一列
                        } else if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {               //出现“无”，并且为最后一个，需赋值
                            DYZ_TwoDimension_Total[_fristRow] = _arr;       //直接结束
                        }
                        continue;               //无、直落都跳过当次循环
                    }

                    //如果是直落，接下来都是直落。路子为红色
                    if (_flag) {
                        _arr.push("100");                       //判断直落，添加结果到_arr中
                    }

                    //如果是直落，并且属于最后一个数组需赋值
                    if (_flag && j == G_TwoDimension[i].length - 1) {
                        //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                        DYZ_TwoDimension_Total[_fristRow] = _arr;
                        _arr = new Array();     //临时第二列的一维数组

                        ////如果是直落，则需要跳一列，方便第三列直接加入新数据“不齐整”
                        //if (_flag) {
                        _fristRow++;
                        //}
                    }

                }
                //#endregion

                //第四列后，从齐整、不齐整先判断
            } else if (i > 2) {
                //判断齐整、不齐整，添加结果到临时数组_arr中
                if (j == 0) {
                    if (G_TwoDimension[i - 1].length == G_TwoDimension[i - 3].length) {                     //i - 1列与i - 3列进行对比
                        //如果_arr[_arr.length-1]为2开头的话，需要new
                        if (_arr.length > 0 && _arr[_arr.length - 1] != undefined && _arr[_arr.length - 1].length > 0 && _arr[_arr.length - 1].substring(0, 1) == "2") {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                        }
                        _arr.push("100");                   //齐整
                    } else {
                        //如果_arr长度大于0，并且_arr[_arr.length-1]=="100"的话，需要new
                        if (_arr.length > 0 && _arr[_arr.length - 1] == "100") {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                        }
                        _arr.push("200");                   //不齐整
                    }

                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需将结果保存起来
                        DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                    }
                } else {
                    //从第二行开始：判断有、无、直落，添加结果到DYZ_TwoDimension_Total中
                    //#region
                    //有：如果当前子路G_TwoDimension[i][j]与上一子路G_TwoDimension[i-1][j]都存在，则有。路子为红色。
                    if (G_TwoDimension[i][j] != undefined && G_TwoDimension[i][j].length > 0 && G_TwoDimension[i - 2][j] != undefined && G_TwoDimension[i - 2][j].length > 0) {

                        //如果上一值为“齐整”，则直接push，否则new一个数组并_fristRow++
                        if (_arr[_arr.length - 1] == "100") {
                            _arr.push("100");        //属于递增添加值
                        } else {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                            _arr.push("100");        //属于递增添加值
                        }
                        if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需将结果保存起来
                            DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                        }

                        //无：路子为蓝色，直落：路子为红色
                    } else {

                        //无：路子为蓝色，并且不是直落
                        if ((G_TwoDimension[i - 2][j] == undefined || G_TwoDimension[i - 2][j].length == 0) && !_flag) {
                            //如果上一值为“齐整”，则new一个数组并_fristRow++，否则直接push
                            if (_arr[_arr.length - 1] == "100") {
                                DYZ_TwoDimension_Total[_fristRow] = _arr;
                                _arr = new Array();     //临时第二列的一维数组
                                _fristRow++;
                                _arr.push("200");        //属于递增添加值
                            } else {
                                _arr.push("200");        //属于递增添加值
                            }

                            //为最后一个，需将结果保存起来
                            if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {
                                DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                            }

                            _flag = true;           //出现一次“无”后，如果接下来还有子路，则都是直落，并且继续跳一列。路子为红色
                            if (G_TwoDimension[i][j + 1] != undefined && G_TwoDimension[i][j + 1].length > 0) {

                                //有直落，将“无”存起来。再跳一列，new一个新数组，用于存“直落”
                                DYZ_TwoDimension_Total[_fristRow] = _arr;
                                _arr = new Array();     //临时第二列的一维数组

                                _fristRow++;        //如果出现无、直落，都需要跳一列
                            }
                            continue;               //无、直落都跳过当次循环
                        }

                        //如果是直落，接下来都是直落。路子为红色
                        if (_flag) {
                            _arr.push("100");                       //判断直落，添加结果到_arr中
                        }

                        //如果是直落，并且属于最后一个数组需赋值
                        if (_flag && j == G_TwoDimension[i].length - 1) {
                            //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            //如果是直落，则需要跳一列，方便第三列直接加入新数据“不齐整”                            
                            _fristRow++;
                        }
                    }
                    //#endregion
                }
            }
        }
    }

    //构造Html代码（图标名、坐标值）并渲染到页面
    CreateIocCoordinateXL(DYZ_TwoDimension_Total, beginRow,room);

}

/*
 * 是否符合大路函数规则
 * 如果二维数组大于等于3，并且第三列第二行有数据，或者第四列有数据
 */
function IsRegulationXL() {
    if (G_TwoDimension.length >= 3 && G_TwoDimension[2].length >= 2 || G_TwoDimension.length >= 4) {
        return true;
    }
    return false;
}

/*
 * 构造Html代码并渲染到页面--小强算法
 */
function CreateIocCoordinateXL(twoWeiArr, beginRow,room) {
    
    //以下生成一个结构与twoWeiArr一模一样的空二维数组
    //用于保存当前twoWeiArr的路子的坐标
    var ZBTwoWeiArr = DeepCopy(twoWeiArr);      //二维数组坐标值    

    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ZBTwoWeiArr[i][j] = "";                                         //置空值，将记录坐标            
        }
    }
    var imgList = "<div class='show'></div>";                           //构造字符串
    var tempImg = "";                           //图片名
    var leftPX = 0;                             //图标左移像素
    var topPX = 0;                              //图标顶移像素
    var ludan = "";                            //当前路单
    var leftArray=[];
    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ludan = twoWeiArr[i][j];
            tempImg = getImgXL(ludan);                      //取得图标名称

            var leftPX_topPX = GetLeft_topPX_DYZ1(i, j, ZBTwoWeiArr,4.17,16.9);         //取得坐标位置

            leftPX = leftPX_topPX.split("-")[0];
            topPX = leftPX_topPX.split("-")[1];

            // 保存坐标
            ZBTwoWeiArr[i][j] = leftPX + "-" + topPX;

            if (ludan.length > 0) {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;"+tempImg+";height:14.58%;width:3.6%;\"></span>";
            }
            else {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;height:14.58%;width:3.6%;\"> </span>";;
            }
        }
    }

    if (beginRow != undefined && beginRow > 0) {
        G_TwoWei_XL = twoWeiArr;
        var divWdith=Math.max.apply(null, leftArray);
        self.postMessage({id:4,html:imgList,divWdith:divWdith,room:room});
    } else {
        DealWenLu(G_TwoWei_DYZ, twoWeiArr, "XL",room);
    }
}

//根据当前路子,获取小路路子图片名称
function getImgXL(ludan) {
    var temp = "";
    if (ludan != undefined && ludan.length > 0 && ludan.substring(0, 1) == "1") {
        temp = "background:#0001F2;border-radius:50%";
    } else {
        temp = "background:#F00010;border-radius:50%";
    }
    return temp;
}

//#endregion

/* 小强路函数 */
//#region
function StartXQL(beginRow,room) {

    var DYZ_TwoDimension_Total = new Array();                  //小路一维数组总数据（通过每个一维的值都是存储一维，变成二维）
    var _arr = new Array();                                   //临时一维数组  

    if (!IsRegulationXQL()) {
        return false;
    } 
    var _fristRow = 0;          //第一列
    for (var i = 0; i < G_TwoDimension.length; i++) {
        var _flag = false;      //标记是否直落
        var _twoRow = 0;        //第二列        
        for (var j = 0; j < G_TwoDimension[i].length; j++) {
            if (i <= 2) continue; _twoRow = _arr.length;
            //先判断有无、直落，从第四列有2个子路开始
            if (i == 3 && G_TwoDimension.length >= 3 && G_TwoDimension[i].length >= 2 && j >= 1) {
                //#region
                //判断有无，添加结果到DYZ_TwoDimension_Total中
                //如果当前子路G_TwoDimension[i][j]与上一子路G_TwoDimension[i-3][j]都存在，则有。路子为红色。
                if (G_TwoDimension[i][j] != undefined && G_TwoDimension[i][j].length > 0 && G_TwoDimension[i - 3][j] != undefined && G_TwoDimension[i - 3][j].length > 0) {
                    _arr.push("100");        //属于递增添加值
                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需赋值
                        DYZ_TwoDimension_Total[_fristRow] = _arr;       //直接结束
                    }
                    //如果属于该列最后一个路子，并且还有下一列，该i列与i-3列不齐整
                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] != undefined && G_TwoDimension[i].length != G_TwoDimension[i - 3].length) {
                        //直落结束，存储直落数据，重新new _arr数组。并跳到第四列，添加“不整齐”
                        DYZ_TwoDimension_Total[_fristRow] = _arr;
                        _arr = new Array();     //临时第二列的一维数组                        
                        _fristRow++;
                    }

                } else {

                    //如果是无，则跳一列。路子为蓝色
                    if ((G_TwoDimension[i - 3][j] == undefined || G_TwoDimension[i - 3][j].length == 0) && !_flag) {

                        //跳一列之前，先将_arr数组赋给DYZ_TwoDimension_Total[_fristRow]，并重新new _arr数组（除第四列第二行外）。如果初始化就是该路子，不应该new，所以要加判断，不等于第四列第二行
                        if (i >= 3 && j > 1) {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            _fristRow++;
                        }

                        _arr.push("200"); 

                        _flag = true;           //出现一次“无”后，如果接下来还有子路，则都是直落，并且继续跳一列。路子为红色
                        if (G_TwoDimension[i][j + 1] != undefined && G_TwoDimension[i][j + 1].length > 0) {

                            //有直落，将“无”存起来。再跳一列，new一个新数组，用于存“直落”
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            _fristRow++;        //如果出现无、直落，都需要跳一列
                        } else if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {               //出现“无”，并且为最后一个，需赋值
                            DYZ_TwoDimension_Total[_fristRow] = _arr;       //直接结束
                        }
                        continue;               //无、直落都跳过当次循环
                    }

                    //如果是直落，接下来都是直落。路子为红色
                    if (_flag) {
                        _arr.push("100");                       //判断直落，添加结果到_arr中
                    }

                    //如果是直落，并且属于最后一个数组需赋值
                    if (_flag && j == G_TwoDimension[i].length - 1) {
                        //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                        DYZ_TwoDimension_Total[_fristRow] = _arr;
                        _arr = new Array();     //临时第二列的一维数组

                        ////如果是直落，则需要跳一列，方便第三列直接加入新数据“不齐整”
                        //if (_flag) {
                        _fristRow++;
                        //}
                    }

                }
                //#endregion

                //第五列后，从齐整、不齐整先判断
            } else if (i > 3) {
                //判断齐整、不齐整，添加结果到临时数组_arr中
                if (j == 0) {
                    if (G_TwoDimension[i - 1].length == G_TwoDimension[i - 4].length) {                     //i - 1列与i - 4列进行对比
                        //如果_arr[_arr.length-1]为2开头的话，需要new
                        if (_arr.length > 0 && _arr[_arr.length - 1] != undefined && _arr[_arr.length - 1].length > 0 && _arr[_arr.length - 1].substring(0, 1) == "2") {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                        }
                        _arr.push("100");                   //齐整
                    } else {
                        //如果_arr长度大于0，并且_arr[_arr.length-1]=="100"的话，需要new
                        if (_arr.length > 0 && _arr[_arr.length - 1] == "100") {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                        }
                        _arr.push("200");                   //不齐整
                    }

                    if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需将结果保存起来
                        DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                    }
                } else {
                    //从第二行开始：判断有、无、直落，添加结果到DYZ_TwoDimension_Total中
                    //#region
                    //有：如果当前子路G_TwoDimension[i][j]与上一子路G_TwoDimension[i-1][j]都存在，则有。路子为红色。
                    if (G_TwoDimension[i][j] != undefined && G_TwoDimension[i][j].length > 0 && G_TwoDimension[i - 3][j] != undefined && G_TwoDimension[i - 3][j].length > 0) {

                        //如果上一值为“齐整”，则直接push，否则new一个数组并_fristRow++
                        if (_arr[_arr.length - 1] == "100") {
                            _arr.push("100");        //属于递增添加值
                        } else {
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组
                            _fristRow++;
                            _arr.push("100");        //属于递增添加值
                        }
                        if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {      //出现“有”，并且为最后一个，需将结果保存起来
                            DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                        }

                        //无：路子为蓝色，直落：路子为红色
                    } else {

                        //无：路子为蓝色，并且不是直落
                        if ((G_TwoDimension[i - 3][j] == undefined || G_TwoDimension[i - 3][j].length == 0) && !_flag) {
                            //如果上一值为“齐整”，则new一个数组并_fristRow++，否则直接push
                            if (_arr[_arr.length - 1] == "100") {
                                DYZ_TwoDimension_Total[_fristRow] = _arr;
                                _arr = new Array();     //临时第二列的一维数组
                                _fristRow++;
                                _arr.push("200");        //属于递增添加值
                            } else {
                                _arr.push("200");        //属于递增添加值
                            }

                            //为最后一个，需将结果保存起来
                            if (j == G_TwoDimension[i].length - 1 && G_TwoDimension[i + 1] == undefined) {
                                DYZ_TwoDimension_Total[_fristRow] = _arr;       //保存结果
                            }

                            _flag = true;           //出现一次“无”后，如果接下来还有子路，则都是直落，并且继续跳一列。路子为红色
                            if (G_TwoDimension[i][j + 1] != undefined && G_TwoDimension[i][j + 1].length > 0) {

                                //有直落，将“无”存起来。再跳一列，new一个新数组，用于存“直落”
                                DYZ_TwoDimension_Total[_fristRow] = _arr;
                                _arr = new Array();     //临时第二列的一维数组

                                _fristRow++;        //如果出现无、直落，都需要跳一列
                            }
                            continue;               //无、直落都跳过当次循环
                        }

                        //如果是直落，接下来都是直落。路子为红色
                        if (_flag) {
                            _arr.push("100");                       //判断直落，添加结果到_arr中
                        }

                        //如果是直落，并且属于最后一个数组需赋值
                        if (_flag && j == G_TwoDimension[i].length - 1) {
                            //直落结束，存储直落数据，重新new _arr数组。并跳到第三列，添加“不整齐”
                            DYZ_TwoDimension_Total[_fristRow] = _arr;
                            _arr = new Array();     //临时第二列的一维数组

                            //如果是直落，则需要跳一列，方便第三列直接加入新数据“不齐整”                            
                            _fristRow++;
                        }
                    }
                    //#endregion
                }
            }
        }
    }

    //构造Html代码（图标名、坐标值）并渲染到页面
    CreateIocCoordinateXQL(DYZ_TwoDimension_Total, beginRow,room);
}

/*
 * 是否符合大路函数规则
 * 如果二维数组大于等于4，并且第四列第二行有数据，或者第五列有数据
 */
function IsRegulationXQL() {
    if (G_TwoDimension.length >= 4 && G_TwoDimension[3].length >= 2 || G_TwoDimension.length >= 4) {
        return true;
    }
    return false;
}


//根据当前路子,获取小路路子图片名称
function getImgXQL(ludan) {
    var temp = "";
    if (ludan != undefined && ludan.length > 0 && ludan.substring(0, 1) == "1") {
        temp = "ludan_10.png";
    } else {
        temp = "ludan_11.png";
    }
    return temp;
}

/*
 * 构造Html代码并渲染到页面--小强算法
 */
function CreateIocCoordinateXQL(twoWeiArr, beginRow,room) {
    
    //以下生成一个结构与twoWeiArr一模一样的空二维数组
    //用于保存当前twoWeiArr的路子的坐标
    var ZBTwoWeiArr = DeepCopy(twoWeiArr);      //二维数组坐标值    

    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ZBTwoWeiArr[i][j] = "";                                         //置空值，将记录坐标            
        }
    }
    var imgList = "<div class='show'></div>";                           //构造字符串
    var tempImg = "";                           //图片名
    var leftPX = 0;                             //图标左移像素
    var topPX = 0;                              //图标顶移像素
    var ludan = "";                            //当前路单
    var leftArray=[];
    for (var i = 0; i < twoWeiArr.length; i++) {
        for (var j = 0; j < twoWeiArr[i].length; j++) {
            ludan = twoWeiArr[i][j];
            tempImg = getImgXQL(ludan);                      //取得图标名称

            var leftPX_topPX = GetLeft_topPX_DYZ1(i, j, ZBTwoWeiArr, 4.2,16.9);         //取得坐标位置

            leftPX = leftPX_topPX.split("-")[0];
            topPX = leftPX_topPX.split("-")[1];

            // 保存坐标
            ZBTwoWeiArr[i][j] = leftPX + "-" + topPX;

            if (ludan.length > 0) {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%;background:url(images/ludan/"+tempImg+");background-size:100% 100%;height:14.58%;width:3.7%;\"></span>";
            }
            else {
                leftArray.push(leftPX);
                imgList += "<span style=\"left: " + leftPX + "%; top: " + topPX + "%\"> </span>";;
            }
        }
    }

    if (beginRow != undefined && beginRow > 0) {
        G_TwoWei_XQL = twoWeiArr;
        var divWdith=Math.max.apply(null, leftArray);
        self.postMessage({id:5,html:imgList,divWdith:divWdith,room:room});
    } else {
        DealWenLu(G_TwoWei_DYZ, twoWeiArr, "XQL",room);
    }
}

//#endregion

/* 处理庄问路、闲问路函数，参数：原二维数组，新二维数组，类型 */
function DealWenLu(oldTwoWeiArr, newTwoWeiArr, genre,room) {
    var arr = new Array();
    //查找最后一个，并且是已有大眼仔或小路、小强路，才加入数组
    if (G_Genre == "ZhuangWenLu") {
        switch (genre) {
            case "DYZ":
                if (newTwoWeiArr != undefined && newTwoWeiArr.length > 0 && newTwoWeiArr[newTwoWeiArr.length - 1] != undefined && newTwoWeiArr[newTwoWeiArr.length - 1].length > 0) {       
                    if (G_TwoDimension != undefined && G_TwoDimension.length > 0 && (G_TwoDimension[1].length > 1 || G_TwoDimension.length > 1)) {
                        G_ZhuangWenLu[0] = newTwoWeiArr[newTwoWeiArr.length - 1][newTwoWeiArr[newTwoWeiArr.length - 1].length - 1];
                    }                    
                }                
                break;
            case "XL":
                if (newTwoWeiArr != undefined && newTwoWeiArr.length > 0 && newTwoWeiArr[newTwoWeiArr.length - 1] != undefined && newTwoWeiArr[newTwoWeiArr.length - 1].length > 0) {
                    if (G_TwoDimension != undefined && G_TwoDimension.length > 1 && (G_TwoDimension[2].length > 1 || G_TwoDimension.length > 2)) {
                        G_ZhuangWenLu[1] = newTwoWeiArr[newTwoWeiArr.length - 1][newTwoWeiArr[newTwoWeiArr.length - 1].length - 1];
                    }
                }
                break;
            case "XQL":
                if (newTwoWeiArr != undefined && newTwoWeiArr.length > 0 && newTwoWeiArr[newTwoWeiArr.length - 1] != undefined && newTwoWeiArr[newTwoWeiArr.length - 1].length > 0) {
                    if (G_TwoDimension != undefined && G_TwoDimension.length > 2 && (G_TwoDimension[3].length > 1 || G_TwoDimension.length > 3)) {
                        G_ZhuangWenLu[2] = newTwoWeiArr[newTwoWeiArr.length - 1][newTwoWeiArr[newTwoWeiArr.length - 1].length - 1];
                    }
                }
                break;
            default:
        }
    } else {
        switch (genre) {
            case "DYZ":
                if (newTwoWeiArr != undefined && newTwoWeiArr.length > 0 && newTwoWeiArr[newTwoWeiArr.length - 1] != undefined && newTwoWeiArr[newTwoWeiArr.length - 1].length > 0) {
                    if (G_TwoDimension != undefined && G_TwoDimension.length > 0 && (G_TwoDimension[1].length > 1 || G_TwoDimension.length > 1)) {
                        G_XianWenLu[0] = newTwoWeiArr[newTwoWeiArr.length - 1][newTwoWeiArr[newTwoWeiArr.length - 1].length - 1];
                    }
                }
                break;
            case "XL":
                if (newTwoWeiArr != undefined && newTwoWeiArr.length > 0 && newTwoWeiArr[newTwoWeiArr.length - 1] != undefined && newTwoWeiArr[newTwoWeiArr.length - 1].length > 0) {
                    if (G_TwoDimension != undefined && G_TwoDimension.length > 1 && (G_TwoDimension[2].length > 1 || G_TwoDimension.length > 2)) {
                        G_XianWenLu[1] = newTwoWeiArr[newTwoWeiArr.length - 1][newTwoWeiArr[newTwoWeiArr.length - 1].length - 1];
                    }
                }
                break;
            case "XQL":
                if (newTwoWeiArr != undefined && newTwoWeiArr.length > 0 && newTwoWeiArr[newTwoWeiArr.length - 1] != undefined && newTwoWeiArr[newTwoWeiArr.length - 1].length > 0) {
                    if (G_TwoDimension != undefined && G_TwoDimension.length > 2 && (G_TwoDimension[3].length > 1 || G_TwoDimension.length > 3)) {
                        G_XianWenLu[2] = newTwoWeiArr[newTwoWeiArr.length - 1][newTwoWeiArr[newTwoWeiArr.length - 1].length - 1];
                    }
                }
                break;
            default:
        }
    }

}


function DealWenLuHtml(room) {
    //庄问路
    if (G_ZhuangWenLu != undefined && G_ZhuangWenLu.length > 0) {
        var zhuang = "";
        for (var i = 0; i < G_ZhuangWenLu.length; i++) {
            if (G_ZhuangWenLu[i] != undefined && G_ZhuangWenLu[i].length > 0) {
                zhuang += getImgName(i, G_ZhuangWenLu[i]);
            }
        }
        self.postMessage({id:7,html:zhuang,room});
    }

    //闲问路
    if (G_XianWenLu != undefined && G_XianWenLu.length > 0) {
        var xian = "";
        for (var i = 0; i < G_XianWenLu.length; i++) {
            if (G_XianWenLu[i] != undefined && G_XianWenLu[i].length > 0) {
                xian += getImgName(i, G_XianWenLu[i]) ;
            }
        }
        self.postMessage({id:8,html:xian,room:room});
    }


    //处理完后，清空数据
    G_ZhuangWenLu = new Array(3);
    G_XianWenLu = new Array(3);
    G_TwoWei_DYZ = [];
    G_TwoWei_XL = [];
    G_TwoWei_XQL = [];
}
self.ww=[];
function getImgName(num, ludan) {
    //if (genre == "ZhuangWenLu") {
    var temp = "";
    switch (num) {
        case 0:
            if (ludan != undefined && ludan.length > 0 && ludan.substring(0, 1) == "1") {
                temp = '<div class="z_box1 " style="border-color: #d40a20"></div>';
                self.ww[0]=1;
            } else {
                temp = '<div class="z_box1 " style="border-color: #143ad9"></div>';
                self.ww[0]=2;
            }
            break;
        case 1:
            if (ludan != undefined && ludan.length > 0 && ludan.substring(0, 1) == "1") {
                temp = '<div class="z_box2 " style="background: #143ad9"></div>';
                self.ww[1]=1;
            } else {
                temp = '<div class="z_box2 " style="background: #d40a20"></div>';
                self.ww[1]=2;
            }
            break;
        case 2:
            if (ludan != undefined && ludan.length > 0 && ludan.substring(0, 1) == "1") {
                temp = '<div class="z_box3 " style="background: #143ad9;"></div>';
                self.ww[2]=1;
            } else {
                temp = '<div class="z_box3 " style="background: #d40a20;"></div>';
                self.ww[2]=2;
            }
            break;
        default:
    }
    return temp;
    //}
}

onmessage=function(el){
    if(el.data.w){//路问庄，路问闲事件
        ShowLudan(el.data.data,el.data.model,false,el.data.room);
    }
    else{
        ShowLudan(el.data.data,el.data.model,true,el.data.room);
    }
}